home *** CD-ROM | disk | FTP | other *** search
/ Power CD / Power CD ATARI-Rechner Lieben.iso / FALCON / INSHAPE / IOB.TXT < prev    next >
Encoding:
Text File  |  1994-01-24  |  15.0 KB  |  676 lines
  1. INSHAPE 3D Modeler & Shader
  2.  
  3.  
  4. Dateiformat - Object
  5.  
  6. (c)1990-93 by Roald Christesen
  7.  
  8.  
  9.  
  10. Diese Formatbeschreibung soll es Ihnen ermöglichen, Programme zu schreiben,
  11. die Objekte im InShape Format lesen und/oder schreiben. Es werden nachein-
  12. ander die benötigten Datentypen, Konstanten und Datenstrukturen erläutert.
  13. Es folgt eine Beschreibung des Datei-Aufbaus. Am Ende wird Schrittweise 
  14. aufgezeigt, wie eine Datei geschrieben wird.
  15.  
  16.  
  17.  
  18. /********
  19.  *
  20.  *    DATENTYPEN
  21.  *
  22.  ********/
  23.  
  24.  
  25. Bezeichn.    Speicherbedarf                                            PureC-Typ
  26. ----------------------------------------------------------------------------
  27. CHAR            signed 8 Bit                                            char
  28. BYTE            signed 8 Bit                                            char
  29. UBYTE            unsigned 8 Bit                                            unsigned char
  30. INT            signed 16 Bit                                            int
  31. UINT            unsigned 16 Bit                                        unsigned int
  32. LONG            signed 32 Bit                                            long
  33. ULONG            unsigned 32 Bit                                        unsigned long
  34. FLOAT            floating point 32 Bit, single precision        float
  35. REAL            floating point 80 Bit, double precision        double
  36.  
  37.  
  38.  
  39. /********
  40.  *
  41.  *    KONSTANTEN
  42.  *
  43.  ********/
  44.  
  45.  
  46. /* Layer Flags */
  47. #define LAYER_DISP            0x1    /* Layer wird angezeigt */
  48. #define LAYER_EDIT            0x2    /* Layer ist editierbar */
  49.  
  50. /* Surface Flags */
  51. #define SRF_IMAGE                0x1    /* Bild verwenden (Image-Mapping) */
  52. #define SRF_NOSHADOW            0x2    /* Surface wirft keine Schatten */
  53. #define SRF_RFILTER            0x4    /* Reflektionen filtern */
  54. #define SRF_TFILTER            0x8    /* Transparenz  filtern */
  55.  
  56. /* Surface Refraction */
  57. #define SRF_REFR_AIR            0
  58. #define SRF_REFR_WATER        1
  59. #define SRF_REFR_GLASS        2
  60. #define SRF_REFR_CRYSTAL    3
  61. #define SRF_REFR_DIAMOND    4
  62.  
  63. /* Image Projektionstyp */
  64. #define IMG_PROJ_PLANE        0    /* Ebenen-Projektion */
  65. #define IMG_PROJ_OCYLINDER    1    /* Zylinder-Projektion auβen */
  66. #define IMG_PROJ_ICYLINDER    2    /* Zylinder-Projektion innen */
  67.  
  68.  
  69.  
  70. /********
  71.  *
  72.  *    STRUKTUREN
  73.  *
  74.  ********/
  75.  
  76.  
  77. V3S
  78.     3D Vektor im float Format (single precision).
  79.  
  80. typedef struct
  81. {
  82.     FLOAT        x, y, z;
  83. } V3S;
  84.  
  85.  
  86. V3D
  87.     3D Vektor im double Format (double precision).
  88.  
  89. typedef struct
  90. {
  91.     REAL        x, y, z;
  92. } V3D;
  93.  
  94.  
  95. V3L
  96.     3D Vektor im long Format
  97.  
  98. typedef struct
  99. {
  100.     LONG    x, y, z;
  101. } V3L;
  102.  
  103.  
  104. LAYER
  105.     Die Layer-Struktur enthält alle Angaben eines Layers aus einem Objekt.
  106.     Diese Struktur ist in der Objekt-Datei 16-fach vorhanden.
  107.  
  108. typedef struct
  109. {
  110.     CHAR        name[17];    /* Layer Name (Nullterminierter String) */
  111.     INT        flags;        /* siehe unten */
  112.     LONG        pnt_n;        /* Anzahl Punkte */
  113.     LONG        pln_n;        /* Anzahl Flächen */
  114. } LAYER;
  115.  
  116. Für flags können folgende Konstanten verknüpft werden:
  117.  
  118.     LAYER_DISP    -    Kennzeichnet, ob das Layer im Objekteditor angezeigt
  119.                         werden soll (Checkbox im Layer-Formular).
  120.  
  121.     LAYER_EDIT    -    Kennzeichnet, ob das Layer im Objekteditor editierbar
  122.                         ist (Checkbox im Layer-Formular).
  123.  
  124.  
  125.  
  126. SRF
  127.     Oberflächenbeschreibung (Surface).
  128.  
  129. typedef struct
  130. {
  131.     CHAR        name[21];    /* Surface Name (Nullterminierter String) */
  132.     SRF_MAT    mat1;            /* Grund-Material (siehe Surface Material) */
  133.     SRF_MAT    mat2;            /* Zweit-Material (bei Verwendung eines         
  134.                                    Pattern's */
  135.     UBYTE        ptrn_id;        /* Pattern Nummer (0 - 29) */
  136.     UBYTE        ptrn_dir;    /* Richtung (0 - 3) */
  137.     FLOAT        ptrn_scale;    /* Skalierung (0.0001 - 1000.0) */
  138.     UBYTE        bump_id;        /* Bumpmap Nummer (0 - 8) */
  139.     FLOAT        bump_amount;/* Intensität (0.0001 - 1.0) */
  140.     FLOAT        bump_scale;    /* Skalierung (0.0001 - 1000.0) */
  141.     UBYTE        flags;        /* siehe unten */
  142. } SRF;
  143.  
  144. Für ptrn_id sind folgende Werte möglich:
  145.  
  146.      0    OFF (default)
  147.      1    Marble
  148.      2    Marble thin
  149.      3    Marble thick
  150.      4    Marble turb.
  151.      5    Granite
  152.      6    Stone
  153.      7    Wood massive
  154.      8    Wood ledges
  155.      9    Random 1
  156.     10    Random 2
  157.     11    Random 3
  158.     12    Random 4
  159.     13    Stripes 1
  160.     14    Stripes 2
  161.     15    Stripes 3
  162.     16    Stripes 4
  163.     17    Spotted 1
  164.     18    Spotted 2
  165.     19    Dotted 1
  166.     20    Dotted 2
  167.     21    Soap
  168.     22    Turbulent
  169.     23    Spherical
  170.     24    Multi color
  171.     25    Tiles
  172.     26    Tiles shift
  173.     27    Tiles narrow
  174.     28    Checkered
  175.     29    Check. query
  176.  
  177. Für ptrn_dir sind folgende Werte möglich:
  178.  
  179.     0    X (default)
  180.     1    Y
  181.     2    Z
  182.     3    Across
  183.  
  184. Für bump_id sind folgende Werte möglich:
  185.  
  186.     0    OFF (default)
  187.     1    Bumps
  188.     2    Dents
  189.     3    Wrinkles
  190.     4    Corrosion
  191.     5    Wave static
  192.     6    Wave anim
  193.     7    Pyramids
  194.     8    Tiles
  195.  
  196. Für flags können folgende Konstanten verknüpft werden:
  197.  
  198.     SRF_IMAGE        -    Bild verwenden (Image-Mapping)
  199.     SRF_NOSHADOW    -    Surface wirft keine Schatten
  200.     SRF_RFILTER        -    R-Filter
  201.     SRF_TFILTER        -    T-Filter
  202.  
  203.  
  204.  
  205. SRF_MAT
  206.     Beschreibt die Beleuchtungseigenschaften. Diese Struktur ist für eine
  207.     Surface zweifach vorhanden (mat1, mat2).
  208.  
  209. typedef struct
  210. {
  211.     UBYTE        r, g, b;    /* Farbe (0 - 255) */
  212.     UBYTE        lu;        /* Eigenleuchten in Prozent (0 - 100) */
  213.     UBYTE        ca,        /* Ambienter Anteil (0 - 100) */
  214.                 cd,        /* Diffuser Anteil (0 - 100) */
  215.                 cs;        /* Spekularer Anteil (0 - 100) */
  216.     UBYTE        se;        /* Exponent für spekularen Anteil (1 - 100) */
  217.     UBYTE        refl;        /* Spiegel-Anteil in Prozent (0 - 100) */
  218.     UBYTE        trns;        /* Transparenter Anteil in Prozent (0 - 100) */
  219.     UBYTE        refr;        /* Brechungsart, siehe unten */
  220.     UBYTE        reserved;
  221. } SRF_MAT;
  222.  
  223. Für refr sind folgende Werte möglich (siehe Konstanten):
  224.  
  225.     SRF_REFR_AIR
  226.     SRF_REFR_WATER
  227.     SRF_REFR_GLASS
  228.     SRF_REFR_CRYSTAL
  229.     SRF_REFR_DIAMOND
  230.  
  231.  
  232.  
  233. VIEW
  234.     Die View-Struktur enhält Informationen für die Darstellung im
  235.     Objekteditor.
  236.  
  237. typedef struct
  238. {
  239.     INT        mode;        /* Projektions-Modus (0 - 7) */
  240.     REAL        zoom;        /* Vergröβerung (1.0 - ca. 850000.0) */
  241.     V3S        pos;        /* Position */
  242.     V3S        rot;        /* Rotation */
  243. } VIEW;
  244.  
  245. Für  mode sind folgende Werte möglich:
  246.  
  247.     0    Front
  248.     1    Back
  249.     2    Top
  250.     3    Bottom
  251.     4    Right
  252.     5    Left
  253.     6    Parallel
  254.     7    Central
  255.  
  256. Der Parameter zoom gibt an, um welchen Faktor die Objektdarstellung im
  257. Objekteditor vergröβert wird. Der Defaultwert ist 1.0.
  258.  
  259. Der Vektor pos beschreibt eine Raumkoordinate relativ zum Objektursprung.
  260. Diese Koordinate des Objektes wird im Zentrum des Arbeitsbereichs angezeigt.
  261. Der Defaultwert von pos ist 0.0, 0.0, 0.0.
  262.  
  263. Der Vektor rot beschreibt die Rotation der Objektdarstellung in den Modi
  264. Parallel und Central. Die Rotation erfolgt in der Reihenfolge x, y, z;
  265.  
  266.  
  267.  
  268. IMG_MAP
  269.     Die IMG_MAP Struktur enhält alle Informationen für das Image Mapping
  270.     in einem Objekt.
  271.  
  272. typedef struct
  273. {
  274.     CHAR        fname[81];    /* Pfad für Image-Mapping (Nullterminiert) */
  275.     BYTE        disp_flag;    /* Projektions Anzeige ein/aus */
  276.     BYTE        proj_mode;    /* Projektionsmodus */
  277.     V3S        crd;            /* Position */
  278.     V3S        rot;            /* Rotation */
  279.     FLOAT        width;        /* Breite */
  280.     FLOAT        radius;        /* Radius */
  281.     FLOAT        angle;        /* Grad */
  282.     INT        w;                /* Bildbreite */
  283.     INT        h;                /* Bildhöhe */
  284. } IMG_MAP;
  285.  
  286. fname            -    Nullterminierter String, der angibt, wo die Bilddatei
  287.                     (Bild im IIM-Format) zu suchen ist (z.B. "F:\MAPPING.IIM" ).
  288.  
  289. disp_flag    -    Gibt an, ob die Projektion im Objekteditor angezeigt werden
  290.                     soll. 0 = aus, 1 = an.
  291.  
  292. proj_mode    -    Projektionsmodus: 0 = Plane, 1 = Cylinder outer,
  293.                     2 = Cylinder inner.
  294.  
  295. crd            -    "Position" aus dem Formular "Image Projection" des
  296.                     Objekteditors.
  297.  
  298. rot            -    "Rotation" aus dem Formular "Image Projection" des
  299.                     Objekteditors.
  300.  
  301. width            -    "Width" aus dem Formular "Image Projection" des
  302.                     Objekteditors (nur bei proj_mode == 0).
  303.  
  304. radius        -    "Radius" aus dem Formular "Image Projection" des
  305.                     Objekteditors (nur bei proj_mode != 0).
  306.  
  307. angle            -    "Angle" aus dem Formular "Image Projection" des
  308.                     Objekteditors (nur bei proj_mode != 0).
  309.  
  310. w                -    Bildbreite in Pixel.
  311.  
  312. h                -    Bildhöhe in Pixel.
  313.  
  314.  
  315.  
  316. /********
  317.  *
  318.  * DATEIAUFBAU
  319.  *
  320.  ********/
  321.  
  322.  
  323. Dateikennung:    *.IOB
  324.  
  325.  
  326.  
  327. Anz.    Typ        Beschreibung                Wertebereich oder Inhalt
  328. ----------------------------------------------------------------------------
  329.   8    CHAR        Header String                "MD_OBJCT"
  330.  20    CHAR        Object Name
  331.   1    LONG        Anzahl Punkte
  332.   1    LONG        Anzahl Flächen
  333.  16    LAYER        Daten der 16 Layer        siehe struct LAYER
  334.   1    INT        Layer ID                        Index des aktiven Layers
  335.  32    SRF        Daten der 32 Surface's    siehe struct SRF        
  336.   1    INT        Surface ID                    Index der aktiven Surface
  337.   1    IMG_MAP    Image mapping Daten        siehe struct IMG_MAP
  338.   1    VIEW        Daten für Viewing            siehe struct VIEW
  339.   1    V3D        Local center
  340.   2    V3D        Rotation Axis
  341.  
  342.  
  343. Der folgende Abschnitt beschreibt einen Punkt und ist "Anzahl Punkte" mal
  344. enthalten.
  345.  
  346.   1    BYTE        Layer ID des Punktes            0 - 15
  347.   1    V3L        Punktkoordinate in
  348.                     1/200000 cm                        -20000000 bis +20000000
  349.  
  350. Der folgende Abschnitt beschreibt eine Fläche und ist "Anzahl Flächen" mal
  351. enthalten. Die Fläche geht durch die Punkte mit den angegebenen Indizes
  352. (Index des 1., 2., 3. und 4. Punktes). Für Dreiecke werden lediglich die
  353. ersten drei Indizes verwendet. Der vierte Index wird auf -1L gesetzt.
  354.  
  355.   1    BYTE        Layer ID der Fläche            0 - 15
  356.   1    BYTE        Surface ID der Fläche        0 - 31
  357.   1    LONG        Index des 1. Punktes            0 - ( Anzahl Punkte - 1 )
  358.   1    LONG        Index des 2. Punktes            0 - ( Anzahl Punkte - 1 )
  359.   1    LONG        Index des 3. Punktes            0 - ( Anzahl Punkte - 1 )
  360.   1    LONG        Index des 4. Punktes
  361.                     oder -1L                            0 - ( Anzahl Punkte - 1 ) oder -1
  362.   1    BYTE        Flags für "weiche" Kanten    0x1 erste  Kante
  363.                                                         0x2 zweite Kante
  364.                                                         0x4 dritte Kante
  365.                                                         0x8 vierte Kante
  366.  
  367.  
  368.  
  369. /********
  370.  *
  371.  *    Schreiben einer Object-Datei
  372.  *
  373.  ********/
  374.  
  375. 1. Header String
  376.  
  377. Der Headerstring besteht immer aus der 8 Zeichen langen Zeichenkette
  378. "MD_OBJCT". Diese kann wie folgt geschrieben werden:
  379.  
  380.  
  381.     Fwrite( fhandle, 8L, "MD_OBJCT" );
  382.  
  383.  
  384.  
  385. 2. Object Name
  386.  
  387. Der Objektname kann eine Länge bis zu 20 Zeichen haben. Bei Namen kürzer
  388. als 20 Zeichen muβ die Zeichenkette nullterminiert sein.
  389.  
  390.  
  391.     CHAR    name[20];
  392.  
  393.     strncpy( name, "Wohnhaus mit Garage", 20L );
  394.     Fwrite( fhandle, 20L, name );
  395.  
  396.  
  397.  
  398. 3. Anzahl Punkte/Flächen
  399.  
  400. Anzahl Punkte und Flächen des gesamten Objekts. Diese müssen mit den
  401. Summen der Punkte bzw. Flächen der 16 Layer übereinstimmen.
  402.  
  403.  
  404.     LONG        pnt_n,        /* Anzahl Punkte */
  405.                 pln_n;        /* Anzahl Flächen */
  406.  
  407.     pnt_n = 160;
  408.     pln_n = 154;
  409.  
  410.     Fwrite( fhandle, sizeof( LONG ), &pnt_n );
  411.     Fwrite( fhandle, sizeof( LONG ), &pln_n );
  412.  
  413.  
  414.  
  415. 4. Layer
  416.  
  417. Es werden sämtliche Parameter aller 16 Layer gesichert.
  418.  
  419.  
  420.     INT        i    
  421.     LAYER        layer[16];        /* 16 Layer Strukturen */
  422.  
  423.     /*** Defaultwerte setzen ... ***/
  424.  
  425.     for ( i = 0; i < 16; i++ )
  426.     {
  427.         sprintf( layer[i].name, "Layer %02d", i + 1 );
  428.         layer[i].flags = LAYER_DISP;
  429.         layer[i].pnt_n = 0;
  430.         layer[i].pln_n = 0;
  431.     }
  432.  
  433.     /*** Verwendete Layer initialisieren ... ***/
  434.  
  435.     strcpy( layer[0].name, "Wohnhaus" );    /* Achtung, max. 16 Zeichen! */
  436.     layer[0].pnt_n = 90;
  437.     layer[0].pln_n = 80;
  438.  
  439.     strcpy( layer[1].name, "Garage" );        /* Achtung, max. 16 Zeichen! */
  440.     layer[1].pnt_n = 70;
  441.     layer[1].pln_n = 74;
  442.  
  443.     /*** Sämtliche Layer schreiben ... */
  444.  
  445.     Fwrite( fhandle, sizeof( LAYER ) * 16, layer );
  446.  
  447.  
  448.  
  449. 5. Layer ID
  450.  
  451. Dies ist der Index des Input-Layer im Objekteditor.
  452.  
  453.  
  454.     INT        layer_id;
  455.  
  456.     layer_id = 0;
  457.     Fwrite( fhandle, sizeof( INT ), &layer_id );
  458.  
  459.  
  460.  
  461. 6. Surface
  462.  
  463. Es werden sämtliche Parameter aller 32 Surfaces gesichert.
  464.  
  465.  
  466.     INT        i;
  467.     SRF        srf[32], *s;
  468.  
  469.     /*** Defaultwerte setzen ... ***/
  470.  
  471.     s = srf;
  472.     for ( i = 0; i < 32; s++, i++  )
  473.     {
  474.         s->name[0] = 0;        /* kein Name */
  475.         s->mat1.r =
  476.         s->mat1.g =
  477.         s->mat1.b = 255;        /* Farbe weiβ */
  478.         s->mat1.lu = 0;
  479.         s->mat1.ca = 10;
  480.         s->mat1.cd = 90;
  481.         s->mat1.cs = 0;
  482.         s->mat1.se = 1;
  483.         s->mat1.refl = 0;
  484.         s->mat1.trns = 0;
  485.         s->mat1.refr = 0;        /* Air, Void */
  486.         s->mat2 = s->mat1;    /* Material 1 und 2 identisch */
  487.         s->ptrn_id = 0;        /* OFF */
  488.         s->ptrn_dir = 0;        /* X */
  489.         s->ptrn_scale = 1.0;
  490.         s->bump_id = 0;        /* OFF */
  491.         s->bump_amount = 0.5;
  492.         s->bump_scale = 1.0;
  493.         s->flags = 0x0;
  494.     }
  495.  
  496.     /*** Verwendete Surfaces initialisieren ... ***/
  497.  
  498.     s = &srf[5];
  499.     strcpy( s->name, "Beton" );
  500.     s->mat1.r = 100;
  501.     s->mat1.g = 100;
  502.     s->mat1.b = 95;
  503.     s->mat1.lu = 0;
  504.     s->mat1.ca = 10;
  505.     s->mat1.cd = 90;
  506.     s->mat1.cs = 0;
  507.     s->mat1.se = 1;
  508.     s->mat1.refl = 0;
  509.     s->mat1.trns = 0;
  510.     s->mat1.refr = 0;        /* Air, Void */
  511.     s->mat2 = s->mat1;    /* Material 1 und 2 bis auf die Farbe         
  512.                                      identisch ... */
  513.     s->mat2.r = 90;
  514.     s->mat2.g = 90;
  515.     s->mat2.b = 85;
  516.     s->ptrn_id = 5;        /* Granite */
  517.     s->ptrn_dir = 0;        /* X */
  518.     s->ptrn_scale = 2.0;
  519.     s->bump_id = 0;        /* OFF */
  520.     s->bump_amount = 0.5;
  521.     s->bump_scale = 1.0;
  522.     s->flags = SRF_NOSHADOW;
  523.  
  524.     Fwrite( fhandle, sizeof( SRF ) * 32, srf );
  525.  
  526.  
  527.  
  528. 7. Surface ID
  529.  
  530. Dies ist die aktive Surface im Objekteditor.
  531.  
  532.  
  533.     INT        srf_id;
  534.  
  535.     srf_id = 0;
  536.     Fwrite( fhandle, sizeof( INT ), &srf_id );
  537.  
  538.  
  539.  
  540. 8. Image Mapping
  541.  
  542. Parameter für das Image Mapping.
  543.  
  544.  
  545.     IMG_MAP        img_map;
  546.  
  547.     strcpy( img_map.fname, "F:\INSHAPE\MAPPING\BILD.IIM" );
  548.     img_map.disp_flag = 1;        /* Darstellung ist eingeschaltet */
  549.     img_map.proj_mode = IMG_PROJ_PLANE;    /* Projektionsmodus */
  550.     img_map.crd.x = 10.0;        /* Position */
  551.     img_map.crd.y = 30.0;
  552.     img_map.crd.z = 25.0;
  553.     img_map.rot.x = 0.0;        /* Rotation */
  554.     img_map.rot.y = 45.0;
  555.     img_map.rot.z = 0.0;
  556.     img_map.width = 100.0;        /* Breite = 100 cm */
  557.     img_map.radius = 0.0;        /* Radius wird bei IMG_PROJ_PLANE        
  558.                                            nicht verwendet */
  559.     img_map.angle = 0.0;        /* dito */
  560.     img_map.w = 320;            /* Bildbreite von BILD.IIM in Pixel */
  561.     img_map.h = 240;            /* Bildhöhe von BILD.IIM in Pixel */
  562.  
  563.     Fwrite( fhandle, sizeof( IMG_MAP ), &img_map );
  564.  
  565.  
  566.  
  567. 9. Viewing
  568.  
  569.  
  570.     VIEW        view;
  571.  
  572.     view.mode = 7;                /* Projektionsmodus: Central */
  573.     view.zoom = 10.0;            /* 10-fache Vergröβerung */
  574.     view.pos.x = 0.0;            /* Position */
  575.     view.pos.y = 0.0;
  576.     view.pos.z = 0.0;
  577.     view.rot.x = 20.0;        /* Rotation */
  578.     view.rot.y = -45.0;
  579.     view.rot.z = 0.0;
  580.  
  581.     Fwrite( fhandle, sizeof( VIEW ), &view );
  582.  
  583.  
  584.  
  585. 10. Local Center
  586.  
  587.  
  588.     V3D        local_center;
  589.  
  590.     local_center.x = 0.0;
  591.     local_center.y = 24.5;
  592.     local_center.z = -10.0;
  593.  
  594.     Fwrite( fhandle, sizeof( VEC3D ), &local_center );
  595.  
  596.  
  597.  
  598. 11. Rotation Axis
  599.  
  600.  
  601.     V3D        axis[2];
  602.  
  603.     axis[0].x = -100.0;
  604.     axis[0].y = -50.0;
  605.     axis[0].z = 0.0;
  606.     axis[1].x = 100.0;
  607.     axis[1].y = 50.0;
  608.     axis[1].z = 0.0;
  609.  
  610.     Fwrite( fhandle, sizeof( V3D ) * 2, axis );
  611.  
  612.  
  613.  
  614. 12. Punkte
  615.  
  616.  
  617.     LONG        i;
  618.     BYTE        layer_id;
  619.     V3L        crd;
  620.     LONG        pnt_n;
  621.  
  622.     pnt_n =        /* von Ihnen zu ergänzen */
  623.  
  624.     for ( i = 0; i < pnt_n; i++ )
  625.     {
  626.         /* Hier werden die Parameter eines Punktes initialisiert.
  627.            Diesen Abschnitt müssen Sie vervollständigen.
  628.         */
  629.  
  630.         layer_id =        /* 0 - 15 */
  631.         crd.x =            /* Achtung: Koordinate in 1/200000 cm */
  632.         crd.y = 
  633.         crd.z =
  634.  
  635.         Fwrite( fhandle, sizeof( BYTE ), &layer_id );
  636.         Fwrite( fhandle, sizeof( V3L ), &crd );
  637.     }
  638.  
  639.  
  640.  
  641. 13. Flächen
  642.  
  643.  
  644.     LONG        i;
  645.     BYTE        layer_id;
  646.     BYTE        srf_id;
  647.     LONG        pnt_id[4];
  648.     BYTE        smooth;
  649.     LONG        pln_n;
  650.  
  651.     pln_n =        /* von Ihnen zu ergänzen */
  652.  
  653.     for ( i = 0; i < pln_n; i++ )
  654.     {
  655.         /* Hier werden die Parameter einer Fläche initialisiert.
  656.            Diesen Abschnitt müssen Sie vervollständigen.
  657.         */
  658.  
  659.         layer_id =        /* 0 - 15 */
  660.         srf_id =            /* 0 - 63 */
  661.         pnt_id[0] =        /* Index des 1. Punktes */
  662.         pnt_id[1] =        /* Index des 2. Punktes */
  663.         pnt_id[2] =        /* Index des 3. Punktes */
  664.         pnt_id[3] =        /* Index des 4. Punktes oder -1L */
  665.         smooth =            /* Kombination aus den Flags 0x1, 0x2, 0x4
  666.                                und 0x8, die kennzeichnen, welche Kanten
  667.                                weich schattiert werden sollen */
  668.  
  669.         Fwrite( fhandle, sizeof( BYTE ), &layer_id );
  670.         Fwrite( fhandle, sizeof( BYTE ), &srf_id );
  671.         Fwrite( fhandle, sizeof( LONG ) * 4, pnt_id );
  672.         Fwrite( fhandle, sizeof( BYTE ), &smooth );
  673.     }
  674.  
  675.  
  676.